home *** CD-ROM | disk | FTP | other *** search
/ POINT Software Programming / PPROG1.ISO / pascal / swag / dos.swg / 0038_SHARE Unit in ASM.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1993-09-26  |  4.7 KB  |  195 lines
  1. (*
  2. From: HELGE HELGESEN
  3. Subj: SHARE.EXE
  4. ---------------------------------------------------------------------------
  5. -> Can I lock the files after the RESET and unlock before / after
  6. -> the close?
  7.  
  8. Yes. This is one advantage of network files. All users running
  9. your program will open the files simultaneously, and when a
  10. process wants to write to a record, it simply locks it. No other
  11. processes can then read or write to the record, though they can
  12. read/write all other records.
  13.  
  14. (I assume you're NOT using text files!)
  15.  
  16. -> I'd like to add a thing that checks if the file is locked
  17. -> before the reset.
  18.  
  19. If a record is locked, then the process still can open the file.
  20.  
  21. -> Does the "lock" occur on the open or the read of the file?
  22.  
  23. What do you mean? You can open a file in numerous ways. If you
  24. open it for shDenyN, then locking is done on record(byte) basis.
  25. If you open it for exclusive(FileMode=2) access or shDenyRW (no
  26. other can access the file) then locking is done on file basis.
  27.  
  28. Here's a short unit with file locking support. It's written for
  29. Turbo Pascal (or Borland Pascal) 7.0, but it should work with
  30. TP60 without many modifications.
  31. SHARE.PAS --->
  32. *)
  33.  
  34. Unit Share;
  35. {
  36.   Utility to allow file sharing on a network
  37.   (c) 1993 Helge Olav Helgesen
  38. }
  39.  
  40. interface
  41.  
  42. uses
  43.   dos;
  44.  
  45. function shShareInstalled: boolean; { check if SHARE is installed }
  46. function LockByte(var thefile; FirstByte, NoBytes: longint): byte;
  47. function UnLockByte(var thefile; FirstByte, NoBytes: longint): byte;
  48. function Lock(var thefile; FirstRec, NoRecs: word): byte;
  49. function UnLock(var thefile; FirstRec, NoRecs: word): byte;
  50.  
  51. const
  52. {
  53.   Here's a list of file file modes you can open a file with. To allow
  54.   multiple access to one file, it should either be marked R/O, or opened
  55.   with shDenyN-mode. To open a file with a spesified mode, do:
  56.  
  57.   FileMode:=shDenyN+shAccessRW; (Add the flags)
  58. }
  59.   shDenyR    = $30; { Deny Read to other Processes }
  60.   shDenyW    = $20; { Deny Write to other Processes }
  61.   shDenyRW   = $10; { Deny access to other Processes }
  62.   shDenyN    = $40; { Deny none - full access to other Processes }
  63.   shAccessR  = $0;  { open for Read access }
  64.   shAccessW  = $1;  { open for Write Access }
  65.   shAccessRW = $2;  { open for both read and write }
  66.   shPrivate  = $80; { private mode - don't know what this is... }
  67.  
  68. implementation { the private part }
  69.  
  70. function shShareInstalled; assembler;
  71. {
  72.   Returns TRUE if Share is installed on the local machine!
  73. }
  74. asm
  75.   mov ax,$1000 { check if SHARE is installed }
  76.   int $2f { call multiplex interrupt }
  77. end; { shShareInstalled }
  78.  
  79. function LockByte; assembler;
  80. {
  81.   Locks a region of bytes in the specified file.
  82. }
  83. asm
  84.   mov ax, $5c00
  85.   les bx, thefile
  86.   mov bx, es:[bx].FileRec.Handle
  87.   les dx, FirstByte
  88.   mov cx, es
  89.   les di, NoBytes
  90.   mov si, es
  91.   int $21
  92.   jc @1
  93.   xor al, al
  94. @1:
  95. end;
  96.  
  97. function Lock; assembler;
  98. {
  99.   Lock records.
  100. }
  101. asm
  102.   les bx, thefile
  103.   mov cx, es:[bx].FileRec.RecSize
  104.   mov ax, FirstRec
  105.   mul cx
  106.   push ax
  107.   push dx
  108.   mov ax, NoRecs
  109.   mul cx
  110.   mov si, dx
  111.   mov di, ax
  112.   pop cx
  113.   pop dx
  114.   mov ax, $5c00
  115.   mov bx, es:[bx].FileRec.Handle
  116.   int $21
  117.   jc @1
  118.   xor al, al
  119. @1:
  120. end;
  121.  
  122. function UnLockByte; assembler;
  123. asm
  124.   mov ax, $5c01
  125.   les bx, thefile
  126.   mov bx, es:[bx].FileRec.Handle
  127.   les dx, FirstByte
  128.   mov cx, es
  129.   les di, NoBytes
  130.   mov si, es
  131.   int $21
  132.   jc @1
  133.   xor al, al
  134. @1:
  135. end;
  136.  
  137. function UnLock; assembler;
  138. asm
  139.   les bx, thefile
  140.   mov cx, es:[bx].FileRec.RecSize
  141.   mov ax, FirstRec
  142.   mul cx
  143.   push ax
  144.   push dx
  145.   mov ax, NoRecs
  146.   mul cx
  147.   mov si, dx
  148.   mov di, ax
  149.   pop cx
  150.   pop dx
  151.   mov ax, $5c01
  152.   mov bx, es:[bx].FileRec.Handle
  153.   int $21
  154.   jc @1
  155.   xor al, al
  156. @1:
  157. end;
  158.  
  159. end.
  160.  
  161.  
  162. They're used this way:
  163. Lock(MyFile, FirstByteToLock, NoBytesToLock);
  164. LockByte(MyFile, FirstRecToLock, NoRecsToLock);
  165.  
  166. Since you're working with records, you probably want to use Lock.
  167. When you want to update a record, this might be the code:
  168.  
  169. Lock(MyFile, Rec, 1);
  170. Write(MyFile, MyRec);
  171. UnLock(MyFile, Rec, 1);
  172.  
  173. You will of course have to make code to check if the lock failed
  174. (any result but 0), you can't write to the record. Always unlock
  175. the record as soon you're done!
  176.  
  177. The last ones are UnLock and UnLockByte. They're used the same
  178. way as Lock and LockByte.
  179.  
  180. And a last note! You can't open a file in a mode that conflicts
  181. with the access other processes have to a file.
  182.  
  183. Eg.
  184.  
  185. if you first open a file with mode shDenyN+shAccessRW, and then
  186. try to open the file again (without closing the first one) with
  187. the mode shDenyRW+shAccessRW, the reset will fail.
  188.  
  189. I'll see if I can make a short program to illustrate how this
  190. works...
  191.  
  192. Hope this helps a litte,
  193.  
  194. ... Helge
  195.